This PR aims to provides a limited support of generics serialization with the help of PhpStanExtractor.

Basically achieving:

class Foo {
    /**
     * @param Generic<\stdClass> $bar
     */
    public function __construct(public $bar){}
}

/**
 * @template T
 */
class Generic {
    /**
     * @param T $variableType
     */
    public function __construct(public $variableType){}
}

$dummy = new \stdClass();
$dummy->prop = 'foo';

$normalizers->normalize(new Foo(bar:new Generic($dummy)));
// ['bar' => ['variableType' => ['prop' => 'foo']]]

$normalizers->denormalize(['bar' => ['variableType' => ['prop' => 'foo']]]);
// new Foo(bar:new Generic($dummy))

It introduces an internal normalization_outer_class_property key in the normalization context to provide the property extractor the type found in the generic.

Its keeping BC with iterables types documented as generics (e.g. array<>, Collection<>)

It's an early stage feature as generics can be very flexible and I encourage everyone to please test it on their own projects and help me catch all the remaining use cases.

It's limited in the sense that it doesn't support:

• Nested generics
• Doesn't support @implements Collection<T>

Debatable topics:

• normalization_outer_class_property key naming
• Should it requires an opt-in / opt-out mechanism ? As it stands, for each OuterObject->InnerObject normalizations there's an added key/value in the context. Hopefully it won't be a huge performance impact but maybe we could let users opting-out.
• I've refactored a bit the handling of promoted property type extraction so that, if both present, @var type will take precedence over @param type.

To Do

• Update the ContextBuilder ?